TypeScript-kontroller för överflödiga egenskaper: Stärk säkerheten för dina objekttyper

            
interface User {
  name: string;
  age: number;
}

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Fel: Objektliteral får endast specificera kända egenskaper, och 'email' finns inte i typen 'User'.
};

            

              
                Copy
              
            
          

            
interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Produkt-ID: ${product.id}, Namn: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Fel: Argument av typen '{ id: number; name: string; price: number; }' kan inte tilldelas till parameter av typen 'Product'.
             // Objektliteral får endast specificera kända egenskaper, och 'price' finns inte i typen 'Product'.
});

            

              
                Copy
              
            
          

            
interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout satt till: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // Egenskapen 'retries' är en överflödig egenskap enligt 'Config'
};

setupConfig(userProvidedConfig); // Inget fel!

// Även om userProvidedConfig har en extra egenskap, hoppas kontrollen över
// eftersom det inte är en objektliteral som skickas direkt.
// TypeScript kontrollerar typen av userProvidedConfig i sig.
// Om userProvidedConfig hade deklarerats med typen Config, skulle ett fel ha uppstått tidigare.
// Men om den deklareras som 'any' eller en bredare typ, skjuts felet upp.

// Ett mer exakt sätt att visa hur det kringgås:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Överflödig egenskap
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Överflödig egenskap
  };
}

setupConfig(anotherConfig as Config); // Inget fel tack vare typassertion och att kontrollen kringgås

// Nyckeln är att 'anotherConfig' inte är en objektliteral vid tilldelningen till setupConfig.
// Om vi hade haft en mellanliggande variabel typad som 'Config' skulle den ursprungliga tilldelningen misslyckas.

// Exempel på mellanliggande variabel:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Fel: Objektliteral får endast specificera kända egenskaper, och 'logging' finns inte i typen 'Config'.
};

            

              
                Copy
              
            
          

            
interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Överflödig egenskap
} as Settings;

// Inget fel här på grund av typassertionen.
// Vi säger till TypeScript: "Lita på mig, det här objektet överensstämmer med Settings."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Detta skulle orsaka ett körningsfel om fontSize inte faktiskt fanns där.

            

              
                Copy
              
            
          

            
interface FlexibleObject {
  id: number;
  [key: string]: any; // Tillåter vilken strängnyckel som helst med vilket värde som helst
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// Inget fel eftersom 'name' och 'version' tillåts av indexsignaturen.
console.log(flexibleItem.name);

            

              
                Copy
              
            
          

            
interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // Överflödig egenskap i förhållande till BaseConfig, men förväntad av den sammanslagna typen
};

// Sprider ut i en ny objektliteral som överensstämmer med ExtendedConfig
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Detta är generellt sett okej eftersom 'finalConfig' deklareras som 'ExtendedConfig'
// och egenskaperna matchar. Kontrollen sker på typen av 'finalConfig'.

// Låt oss överväga ett scenario där det *skulle* misslyckas:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' är extra här
const data2 = { key: 'xyz', status: 'active' }; // 'status' är extra här

// Försöker tilldela till en typ som inte hanterar extra egenskaper

// const combined: SmallConfig = {
//   ...data1, // Fel: Objektliteral får endast specificera kända egenskaper, och 'value' finns inte i typen 'SmallConfig'.
//   ...data2  // Fel: Objektliteral får endast specificera kända egenskaper, och 'status' finns inte i typen 'SmallConfig'.
// };

// Felet uppstår eftersom objektliteralen som bildas av spread-syntaxen
// innehåller egenskaper ('value', 'status') som inte finns i 'SmallConfig'.

// Om vi skapar en mellanliggande variabel med en bredare typ:

const temp: any = {
  ...data1,
  ...data2
};

// När vi sedan tilldelar till SmallConfig, kringgås kontrollen för överflödiga egenskaper vid den initiala skapandet av literalen,
// men typkontrollen vid tilldelningen kan fortfarande ske om temp's typ infereras striktare.
// Men om temp är 'any' sker ingen kontroll förrän vid tilldelningen till 'combined'.

// Låt oss förfina förståelsen av spread med kontroller för överflödiga egenskaper:
// Kontrollen sker när objektliteralen som skapats av spread-syntaxen tilldelas
// till en variabel eller skickas till en funktion som förväntar sig en mer specifik typ.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Detta kommer att misslyckas om SpecificShape inte tillåter 'extra1' eller 'extra2':
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// Anledningen till att det misslyckas är att spread-syntaxen i praktiken skapar en ny objektliteral.
// Om objA och objB hade överlappande nycklar, skulle den senare vinna. Kompilatorn
// ser denna resulterande literal och kontrollerar den mot 'SpecificShape'.

// För att få det att fungera kan du behöva ett mellansteg eller en mer tillåtande typ:

const tempObj = {
  ...objA,
  ...objB
};

// Om nu tempObj har egenskaper som inte finns i SpecificShape, kommer tilldelningen att misslyckas:
// const mergedCorrected: SpecificShape = tempObj; // Fel: Objektliteral får endast specificera kända egenskaper...

// Nyckeln är att kompilatorn analyserar formen på den objektliteral som bildas.
// Om den literalen innehåller egenskaper som inte är definierade i måltypen är det ett fel.

// Det typiska användningsfallet för spread-syntax med kontroller för överflödiga egenskaper:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// Det är här kontrollen för överflödiga egenskaper är relevant:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Fel: Objektliteral får endast specificera kända egenskaper, och 'lastLogin' finns inte i typen 'AdminProfile'.
// };

// Objektliteralen som skapats av spread-syntaxen har 'lastLogin', som inte finns i 'AdminProfile'.
// För att fixa detta bör 'adminData' helst överensstämma med AdminProfile eller så bör den överflödiga egenskapen hanteras.

// Korrigerat tillvägagångssätt:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// Eller vanligare med ett typalias och rest-syntax:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Inget fel, eftersom 'email' och 'isAdmin' fångas upp av indexsignaturen i UserProfileWithMetadata.
console.log(user1.email);
console.log(user1.isAdmin);

// Ett annat sätt att använda rest-parametrar i en typdefinition:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Fånga upp alla andra egenskaper i 'extraConfig'
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

            

              
                Copy
              
            
          

            
interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Anställnings-ID: ${employeeId}`);
  console.log(`Avdelning: ${department}`);
  console.log('Övriga detaljer:', otherDetails);
  // otherDetails kommer att innehålla alla egenskaper som inte uttryckligen destrukturerats,
  // som 'salary', 'startDate', etc.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// Även om employeeInfo hade en extra egenskap från början, kringgås kontrollen för överflödiga egenskaper
// om funktionssignaturen accepterar det (t.ex. med en indexsignatur).
// Om processEmployeeData var strikt typad som 'Employee', och employeeInfo hade 'salary',
// skulle ett fel uppstå OM employeeInfo var en objektliteral som skickades direkt.
// Men här är employeeInfo en variabel, och funktionens typ hanterar extra egenskaper.

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
  email?: string; // Valfri e-post
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Om vi försöker lägga till en egenskap som inte finns i UserProfile:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Fel: Objektliteral får endast specificera kända egenskaper, och 'phoneNumber' finns inte i typen 'UserProfile'.

            

              
                Copy
              
            
          

            
interface ProductConfig {
  id: string;
  version: string;
}

// Föreställ dig att detta kommer från en extern källa eller en mindre strikt modul
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Överflödig egenskap
};

// Om du vet att 'externalConfig' alltid kommer att ha 'id' och 'version' och du vill behandla det som ProductConfig:
const productConfig = externalConfig as ProductConfig;

// Denna assertion kringgår kontrollen för överflödiga egenskaper på `externalConfig`.
// Men om du skulle skicka en objektliteral direkt:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Fel: Objektliteral får endast specificera kända egenskaper, och 'debugMode' finns inte i typen 'ProductConfig'.

            

              
                Copy
              
            
          

            
interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // TypeScript vet att 'shape' är en Circle här
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // TypeScript vet att 'shape' är en Square här
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Använder 'as const' för inferens av literaltyp
  radius: 10,
  color: 'red' // Överflödig egenskap
};

// När den skickas till calculateArea förväntar sig funktionssignaturen 'Shape'.
// Funktionen i sig kommer korrekt att komma åt 'kind'.
// Om calculateArea hade förväntat sig 'Circle' direkt och tagit emot circleData
// som en objektliteral, skulle 'color' ha varit ett problem.

// Låt oss illustrera kontrollen för överflödiga egenskaper med en funktion som förväntar sig en specifik subtyp:

function processCircle(circle: Circle) {
  console.log(`Bearbetar cirkel med radie: ${circle.radius}`);
}

// processCircle(circleData); // Fel: Argument av typen '{ kind: "circle"; radius: number; color: string; }' kan inte tilldelas till parameter av typen 'Circle'.
                         // Objektliteral får endast specificera kända egenskaper, och 'color' finns inte i typen 'Circle'.

// För att fixa detta kan du destrukturera eller använda en mer tillåtande typ för circleData:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// Eller definiera circleData så att den inkluderar en bredare typ:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Nu fungerar det.

            

              
                Copy